perm filename HELP.DAT[PNT,HE]9 blob
sn#533220 filedate 1980-09-03 generic text, type T, neo UTF8
COMMENT The format of this file is as follows: each entry
begins with an ∀ and ends with a ∃. Within
each entry, the fields are separated by back slashes (\) separating
the entry number, keyword,and the data. A formfeed is inserted
after every tenth message. The message area begins after the symbol percent symbol.
If you make any changes to this file, it will not be permanent.
Please do not insert any new ∀∃\ or percent signs into this file if you write it
with E. Note also that all tabs are replaced by the right number of spaces.
If this file gets messed up, a fresh copy can be generated by
executing HELP0.SAI.
%
∀\1\?\displays this information\∃
∀\2\BUGS\what to do about apparent bugs\∃
∀\3\\ If there appears to be bugs, or something does
not work the way you think it should, a good source is this helper or
the AL USERS' MANUAL, which you should be familiar with if
you are running this program by yourself.
If either of these sources do not convince you it is not a bug,
you can log down the error and what you were doing at the time, and
your cusswords by getting out of the helper and typing these
things between open and close brace pairs{}. e.g. {arm refused to move}
This will be treated as a comment, but will be recorded in a logging
file.
When you are done with POINTY, send or mail MSM a message
saying that there were bugs, and complaints were logged in the
logging file.\∃
∀\4\\
Type one of the keywords on the left column. If you
don't understand any of this, type HELP\∃
∀\5\HELP\help on the use of this helper\∃
∀\6\\ This helper is organized as as a directed
graph with loops, and to each node there corresponds a message.
Terminal nodes have no keyword associated with them, whereas
inside nodes do.
If the message is too long to fit on the screen,
<formfeed> and <vert tab> may be used to scroll up and down the
screen the way E does it. If the message can fit in one screenful
these will have no effect.
At any time in the help mode, the following keywords
are valid:
a) The list of keywords on the left hand column of the
screen.
b) The list of keywords on the left hand column of the
screen the previous time.
c) The list of keywords on the keyword stack at the
bottom of the screen.
If you type a valid keyword, that keyword will appear
as the last element of the keyword stack. Since keywords
are not repeated on the keyword stack, this means that sometimes
the keyword stack may be trimmed back.
If an invalid keyword is typed, it is as if you typed ?
but the keyword stack will not be cut back.
Note that you are now in a different mode. Normal POINTY
or AL commands will not work until you get out of the helper mode
by using the DONE command.\∃
∀\7\??\ideas for other help topics\∃
∀\8\\ If there is a help topic that you think should
be here that isnt, please send a message to MSM about it, with
suggestions for the text of the message and at what level it should be
invoked.\∃
∀\9\UP\goes up a level on the keyword stack\∃
∀\10\MENU\gives a list of toplevel instructions\∃
∀\11\RES\gives a list of reserved words\∃
∀\12\\These are reserved words:
ABORT ACOS AFFIX ALL AND ARRAY ASIN ATAN2 AXIS
BAIL BEGIN BY
CASE CENTER CLOSE COBEGIN COEND COMMENT CONSTRUCT COS
DDT DEFINE DELETE DISPLAY DO DRIVE DUMP_VARIABLES
ECHOOFF ECHOON EDIT EEDIT END EQV EVAL EVENT
EXIT EXP {FCONSTRUCT} FOR FRAME FUNCTION
GATHER GRAPH HELP IF INT INTO INV
LOAD_VARIABLES
MAX MIN MOD MOVE MOVEX MOVEY MOVEZ
NODISPLAY NOUPDATE ON OPEN OR ORIENT
PARK POS PRINT PROCEDURE PROMPT QBAIL QREAD
READ READWRIST REDEFINE REDISPLAY REFERENCE
REL RENAME RESETSTATUS RESUME_MESSAGE RETURN RETRY ROT
SAVECOREIMAGE
SCALAR SETBASE SETSTATUS SETSTIFF SHOW SIGNAL
SIN SQRT STOP STOPMESSAGE SUBTREE
TAN TO TRANS UNFIX UNIT UPDATE
VALUE VECTOR VTT05_OFF VT05_ON WAIT
WHILE WRIST WRITE WRT
XCOORD XOR YCOORD XCOORD\∃
∀\13\RESH\gives one line descriptions of the reserved words\∃
∀\14\\ABORT stops the current action and throws you into DDT
ACOS arc cosine
AFFIX affix statement
ALL reserved word used with WRITE, DELETE, etc
ARRAY used for array declarations
ASIN arc sine
ATAN2 arctangent taking two arguments
BAIL calls the SAIL debugger: not available in all versions
BEGIN denotes beginning of a block
BY reserved word used in MOVE, OPEN, CLOSE, AFFIX
CASE control statement
CLOSE close the hand
COBEGIN parallel control
COEND indicates end of COBEGIN block
COMMENT comment statment: non executabl statement
CONSTRUCT makes a trans out of three vectors
COS cosine function
DDT throws you into DDT: you better know what you are doing
DEFINE macro definitions
DELETE deletes variables
DISPLAY displays appropriate data types
DO loop
DUMP_VARIABLES saves all the values of variables in a disk file
DRIVE moves individual joints
ECHOOFF suppresses printing of input file: normal mode for QREAD
ECHOON prints out input file: normal mode for READ
EDIT edits values of variable or macro
EEDIT swaps to E for editing
END ends a block
≡ EQV equivalence
EVAL direct evaluation
EVENT event declaration
EXIT exits from POINTY, can resume by typing CONT
EXP exponentiation
FCONSTRUCT constructs frame from 3 transes
FOR loop iteration
FRAME frame definition or declaration
FUNCTION no longer valid
GATHER to gather data
HELP gets the help moe
IF if control statement
INT integer part of a scalar expression
INTO used for COPY/MERGE
INV inverse trans
LOAD_VARIABLES reads in the variables from a dump file
LOG logarithm
MAX maximum of two expressions
MIN minimum of two scalar expressions
MOD modulus (remainder)
MOVE general motion statement
MOVEX motion in the X direction
MOVEY motion in the Y direction
MOVEZ motion in the Z direction
NODISPLAY shuts off the display
NOPUDATE does not update the display
ON condition monitor or used in motion statement
OPEN pertains to the hand opening
∨ OR boolean OR operator
ORIENT the rotation part of a frame or trans
PARK parks the arm
POS vector part of a frame or trans
PRINT prints arguments on the VT05
PROCEDURE procedure declaration
PROMPT waits for user to type P at the VT05
QBAIL like BAIL, but takes input from QUERY.TXT on current PPN
QREAD like READ, but does not print on terminal what is being read
READ reads in the appropriate file
READWRIST reads the wrist
REDEFINE changes definition of a macro
REDISPLAY gets the normal table mode
REFERENCE type of argument used for parameter specification
REL relative positons
RENAME change the name of a variable
RESETSTATUS change the value of compiler parameters to 0
RESUME_MESSAGE the message to print out when resuming execution
RETURN gets out of a procedure
RETRY performs the motion again; valid only within error condition monitor
ROT the rotation operator or declaration
SAVECOREIMAGE saves the state of the 10 and 11
SCALAR used for declarations
SETBASE assumes there is zero force on the wrist
SETSTATUS changes the values of compiler parameters
SETSTIFF sets wrist stiffness matrix
SHOW displays values of a list of variables
SIGNAL signals the event
SIN the sine function
SQRT the square root function
STOPMESSAGE message received from interjob mail system is ended
TAN tangent function
TO used in AFFIX,MOVE,OPEN
TRANS used for declaration and to make trans data type
UNFIX the UNFIX statement
UNIT computes a unit vector
UPDATE updates the display
VALUE used for declaration of procedure parameters
VECTOR constructing data type or declaring vectors
VT05_OFF turns off updating of VT05
VT05_ON turns on updating of VT05 (default)
WAIT used with event
WHILE loop
WRIST reads the force wrist readings
WRITE writes AL declarations into a file
WRT operator
XCOORD refers to x-coordinate of a vector,trans or frame
XOR does exclusive or
YCOORD refers to y-coordinate of a vector,trans or frame
ZCOORD refers to z-coordinate of a vector,trans or frame\∃
∀\15\DISP\describes display commands\∃
∀\16\\The display commands relate to the display on the user
and there are several modes of display: the table display mode (the
display you get on starting up), the type display mode, the nodisplay
mode, and the variable display mode.
NODISPLAY takes no arguments, shuts off displays
REDISPLAY gets you back into the table display mode
DISPLAY <type> displays all the variables of type <type>,
where <type> may be SCALAR,VECTOR,ROT,TRANS,FRAME,
EVENT,MACRO,PROCEDURE
UPDATE forces immediate update of the display
NOUPDATE prevents updating of the display
SHOW <variable list> displays the variables in the <variable list>\∃
∀\17\ELF\gives information on the ELF, or PDP-11 interface\∃
∀\18\\ The ELF is the name given to the interface
between the PDP-10 and PDP-11. Before POINTY can be run successfully,
the runtime system must be loaded and started across the ELF. The
ELF is a sharable device, which means that others may also use the
interface.
To get POINTY to work, type
R POINTY<cr>
If the ELF is being used by somebody else, you may
be able to execute the program. However, if someone else is using the
arms, you will not be able to run POINTY.
If the ARM is available, it will be assigned to your job
and the POINTY program started on the PDP-11.
Sometimes there may be errors that cause the
program to stop executing and enter DDT. When that happens,
try to find out what is wrong, and get it to continue executing,
normally by typing either <alt>P or RETRY<alt>G if you are
asked to do so or the interactive part on the PDP-10 will not work.
Don't type <alt>G or you will mess up whatever you did.\∃
∀\19\VT05\describes VT05\∃
∀\20\\The VT05 is a terminal directly connected to the PDP-11.
It prints out the status of the arm joints and limits.
VT05_ON prints out the joint angles continuously;
VT05_OFF shuts off the printing of joint angles on VT05
VT05_YELLOW displays the YELLOW ARM data
VT05_BLUE displays the BLUE ARM data\∃
∀\21\OPER\shows available operators and functions\∃
∀\22\LOGIC\gives a list of logical operators\∃
∀\23\RELAT\list of relational operators\∃
∀\24\ARITH\gives a list of arithmetic operators\∃
∀\25\FUNCT\gives a list of available functions\∃
∀\26\SCOPS\list of operations that give a scalar result\∃
∀\27\VTOPS\list of operations giving vector result\∃
∀\28\RTOPS\list of operations giving rot result\∃
∀\29\TROPS\list of operations giving trans/frame result\∃
∀\30\EXOPS\extraction functions\∃
∀\31\IMPOPS\implicit data types\∃
∀\32\\≡ EQV equivalence \∃
∀\33\\∨ OR logical OR\∃
∀\34\\⊗ XOR exclusive OR\∃
∀\35\\∧ AND logical AND\∃
∀\36\\≤ < ≠ = > ≥ relational operators\∃
∀\37\\+ addition\∃
∀\38\\- negation or difference\∃
∀\39\\. vector dot product\∃
∀\40\\* product\∃
∀\41\\/ division\∃
∀\42\\MAX maximum of two operands\∃
∀\43\\MIN minimum of two operands\∃
∀\44\\DIV integer division quotient\∃
∀\45\\MOD integer division remainder\∃
∀\46\\REL vector or trans relative to frame\∃
∀\47\\WRT vector or trans with respect to frame\∃
∀\48\\→ relative transform between two frames or transes\∃
∀\49\\↑ expoenentiation\∃
∀\50\\¬ logical not\∃
∀\51\\ORIENT rotation part of a frame or trans\∃
∀\52\\UNIT conversion of a vector to unit vector\∃
∀\53\\AXIS the axis of rotation\∃
∀\54\\INV inverse of a rot or trans\∃
∀\55\\INT integer part of a scalar\∃
∀\56\\CONSTRUCT constructs a frame from 3 vectors\∃
∀\57\\SQRT square root function\∃
∀\58\\SIN COS TAN ASIN ACOS ATAN2 relevant trig functions\∃
∀\59\\LOG EXP relevant transcendental functions\∃
∀\60\\↓ downward orientation\∃
∀\61\\$ station orientation\∃
∀\62\\α bpark orientation(???)\∃
∀\63\\{EVAL evaluate immediate}\∃
∀\64\\|..| magnitude of scalar or vector, or angle of rotation\∃
∀\65\\( .. ) implicit data type declaration\∃
∀\66\\FRAME VECTOR TRANS ROT make the appropriate data type\∃
∀\67\\XCOORD YCOORD ZCOORD the relevant component of the vector or trans\∃
∀\68\\The following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
s + s scalar addition
s - s scalar subtraction
s * s scalar multiplication
s / s scalar division
s ↑ s scalar raised to a scalar power
s MAX s maximum
s MIN s minimum
INT(s) integer part of s
s DIV s integer quotient after applying INT to each argument
s MOD s integer remainder after applying INT to each argument
v . v dot product of two vectors
|s| absolute value of a scalar
|v| magnitude of vector (vector norm)
|r| extracts angle of rotation
INSCALAR reads a scalar from the console
Scalar functions
SQRT(s) square root
SIN(s) sine (all trigonometric functions are in degrees)
COS(s) cosine
TAN(s) tangent
ASIN(s) arc-sine
ACOS(s) arc-cosine
ATAN2(s,s) arc-tangent of s/s
LOG(s) natural logarithm
EXP(s) e raised to the s power
s <rel> s returns true if relation is satisfied, else false
possible relations are: <,≤,=,≥,>,≠
s ∧ s logical and
s ∨ s logical or
s ⊗ s logical exclusive or
s ≡ s logical equivalence
¬ s logical not
QUERY reads a boolean from the console\∃
∀\69\\The following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
VECTOR(s,s,s) construct vector given (x,y,z) components
s * v dilation of a vector
v / s contraction of a vector
v + v vector addition
v - v vector subtraction
v * v vector cross product
r * v rotation of a vector
t * v transformation of a vector
f * v transformation of a vector - shorthand for (station → f) * v
v WRT f vector in station coordinates pointing
the same way as v points in f's coordinate
system. v WRT f ≡ ORIENT(f)*v ≡ (f*v) - POS(f)
UNIT(v) vector of unit length with same direction as v
POS(f) vector position of frame or trans
AXIS(r) axis of rotation\∃
∀\70\\The following operations return a scalar value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
ROT(v,s) constructs rotation of s degrees about v
ORIENT(f) orientation of a frame or trans
r * r composition of two rotations (the one on the right
is applied first)\∃
∀\71\\The following operations return a frame value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
FRAME(r,v) constructs frame of orientation r at position v
CONSTRUCT(v,v,v) makes a frame: first vector gives the position,
second a point on the x-axis,
third is a point in the xy-plane
f + v translation of a frame
f - v translation of a frame
t * f transformation of a frame
f * f transformation of a frame - shorthand for (station → f) * f\∃
∀\72\\The following operations return a frame value.
These abbreviations are used: s = scalar,v = vector,r = rotation,
f = frame,t = trans.
TRANS(r,v) constructs trans which will cause a rotation of r
followed by a translation of v
f → f transformation which maps from the first frame
to the second
t * t composition of two transes (the one on the right is
applied first)
INV(t) take the inverse of t\∃
∀\73\EXP\valid expressions\∃
∀\74\OPS\types of expressions\∃
∀\75\BNF\bnf definition of expressions\∃
∀\76\PRI\priority of operators\∃
∀\77\\The following are valid expressions:
S=scalar, V=vector,R=rot,T=trans,F=frame
RESULT OPERATION
S: S+S,S-S,S*S,S/S,S↑S,LOG(S),EXP(S),INT(S),S MAX S,S MIN S,
SIN(S),COS(S),TAN(S),ASIN(S),ACOS(S),ATAN2(S,S),
V.V
V: V+V,V-V,V*V,V*S,V/S,(S,S,S),VECTOR(S,S,S)
POS(F),POS(T)
R: ROT(V,S),ORIENT(F)
F: FRAME(R,V)
T: TRANS(R,V),(R,V)\∃
∀\78\\The following is the recursive definition of
expressions in bnf form:
<expression> ::= <befact>{{OR|XOR <befact>}}
<befact> ::= <bterm>{{AND <bterm>}}
<bterm> ::= <arith_exp>| <arith_exp> <rel> <arith_exp>
<arith_exp> ::= {+|-} <term> {{+|- <term>}}
<term> ::= <factor> {{*|/ <factor>}}
<factor> ::= <pfactor>{↑ <pfactor>}
<pfactor> ::= (<expression>) or |<expression>| or
<constant> or <id> or ¬ <pfactor> or funct or
funct(<expression>{{,<expression}})\∃
∀\79\\ The operators in AL generally follow
normal precedence rules, i.e., functions are evaluated first,
followed by exponentiations before multiplications or divisions,
which in turn are performed before additions and subtractions.
The order of operation can be changed by including parentheses
at appropriate points. In an expression where several operators
of the same precedence occur at the same level, the operations
are performed from left to right.
functions, (), | |, NOT
WRT → ↑
* / . MAX MIN DIV MOD
+ -
= ≠ < > ≤ ≥
∧
∨ ⊗
≡\∃
∀\80\FILE\Gives the file management commands\∃
∀\81\PHOTO\Saves the terminal session\∃
∀\82\WRITE\Saves AL declarations, macros, procedures and arrays\∃
∀\83\READ\Reads AL instructions from a disk file\∃
∀\84\LOAD\Fast loads variables saved from a file\∃
∀\85\DUMP\Dumps variables into a file\∃
∀\86\SAVE\Saves the core image\∃
∀\87\\ When you run POINTY, your terminal session
will be logged automatically into POINTY.PHT[PNT,HE].
If you wish to record your session
in another file as well, the command PHOTO <filename> will save
the terminal input into <filename>. Once PHOTO is called, it will
keep on recording until you make another call to PHOTO in which case
it will stop recording in the old file and start recording
into the new file name.
Recording can only be done into a file that is not being
referenced by some other user or job, and the file is written out
every 6 lines or so, so that if you accidentally kill your job
or the system crashes (knock on wood!) you will have a record of
your terminal session.\∃
∀\88\\ The write command permits the state of the world
to be saved on a disk file. The syntax is as follows:
WRITE ALL|<var_list> {INTO <filename>}
The instruction will write the values of all the variables,
arrays, macros or the selected ones into the relevant file.
If the filename is not specified, it will be written into
the last file into which AL declarations were written.\∃
∀\89\\ File input of AL commands can be done by means of
the READ <filename> command. The file will be read to completion unless
<ESCAPE> I is typed.
Note that defaults instructions will not work from file input,
and that statements must be separated by semicolons.\∃
∀\90\\ Fast loads variables and procedure and macro
declarations from a file written out by the DUMP_VARIABLES command.
The syntax is as follows:
LOAD_VARIABLES <filename>
This procedure can only be invoked at toplevel.\∃
∀\91\\ Dumps variable values and procedure and macro
declarations into a file in a form readable by the LOAD_VARIABLES
command. The syntax is as follows:
DUMP_VARIABLES <filename>
This command can only be invoked at top level.\∃
∀\92\\ Saves the core image of the 10 and the 11.
This command saves the entire state of the program in a dump file
with extension .DMP. The syntax is as follows:
SAVECOREIMAGE <filename>
Note that you will not be allowed to save a file called POINTY.DMP.
(This is to protect against accidentally destroying the main
core image that runs the POINTY system.)
This will save a huge file (about 150K currently) and may easily
send you over your disk allocation, so be sparing in its use.
This command can only be invoked at top level.
After saving the core image, the program will continue
executing. If you want to get this state back at a later
time, you can do so by doing the monitor command
RU <filename>\∃
∀\93\ESC_I\ESCAPE I command\∃
∀\94\\ Hitting the <ESC> key followed by an I will
interrupt whatever the PDP-10 is doing and throw you back to the
top level. Any type ahead will be destroyed. If a file is being
read, the rest of the file will be ignored.
This command is useful when there is some error in the
input file which causes the generation of a large number of error
messages, and you want to get command back to top level.
A second place this command is useful is when
there is some problem on the 11 and the system seems to be wedged.
In this case it is still possible to save the values of variables
that the PDP-10 knows about and start over.
Typing <esc> I may not work if it is done during
initialization, since the interrupt is not enabled at the
end of initialization.\∃
∀\95\STATE\classes of statements\∃
∀\96\←\assignment statement\∃
∀\97\\ The assignment statement is of the form
<variable> ← <expression>
or component(<variable>) ← <expression>
where component is XCOORD,YCOORD,ZCOORD,POS or ORIENT.
The data types on both sides of the assignment statement must
be the same for the assignment to work, except that trans
expressions may be assigned to frames.
In the first form, if <variable> has not been declared,
POINTY will declare it to be the same data type as the expression
on the right hand side. Predefined variables or constants
like BARM, YARM, BHAND, YHAND, XHAT,YHAT,ZHAT,NILVECT may
not have values assigned to them.
The planning assignment operator ←← of AL is recognized
and parsed, but is essentially a NOOP execpt that it serves
to declare the variable on the left hand side if it has not
already been declared.\∃
∀\98\MOT\list of motion commands\∃
∀\99\OPEN\opens the hand\∃
∀\100\CLOS\similar to OPEN\∃
∀\101\\ The OPEN/CLOSE command applied to
a hand causes the hand opening to go to the desired value.
The syntax is as follows:
OPEN <hand> TO|BY <scalar_exp>
CLOSE <hand> TO|BY <scalar_exp>
permitting the use of an absolute or relative value.
Note that OPEN bhand BY 1 is the same as CLOSE bhand BY -1.\∃
∀\102\MOVE\moves the arm\∃
∀\103\\ The MOVE command specifies the motion of
the specified frame to the desired destination which may
be in absolute or relative terms. The syntax is as follows:
MOVE <frame> TO <frame1>,<frame2>,...,<framen>
<condition monitors>
where n≤9. Currently the condition monitors available are
the FORCE and TORQUE, ERROR, DURATION, EXPRESSION, and EVENT
condition monitors whose syntax are as follows:
ON FORCE(direction) <rel> <scalar_exp> {IN HAND|STATION}
DO <statement>
where <rel> is ≥ or < and direction is XHAT,YHAT, or ZHAT
ON ERROR=<compile time constant> DO <statement>.
ON DURATION > <scalar_exp> DO <statement>
ON <scalar_exp> DO <statement>
ON <event_id> DO <statement>
In <statement> it is possible to ask for RETRY and the current
motion command will be executed. The compile time constant must
set certain bits, and may be abbreviated by means of the following
macros which are already predefined:
DEFINE PANIC_BUTTON=⊂ 1024⊃; { = '2000 }
DEFINE EXCESSIVE_FORCE=⊂ 2048⊃; { ='4000 }
DEFINE TIME_OUT=⊂ 4096⊃; { ='10000 }
Clauses available are the DURATION, STIFFNESS, WRIST
ZEROED/NOT ZEROED, WOBBLE, SPEED_FACTOR, FORCE_FRAME
with the following syntax:
WITH DURATION=n where n is a compile time constant
WITH STIFFNESS = (<vect>,<vect>,<trans>)
WITH STIFFNESS = (<vect>,<vect>) AT <trans>
WITH WRIST ZEROED
WITH WRIST NOT ZEROED
WITH WOBBLE=n where n is a compile time constant
WITH SPEED_FACTOR = n where n is a compile time constant
WITH FORCE_FRAME = <trans> {IN HAND|STATION}\∃
∀\104\CENTER\does a grasp\∃
∀\105\\ The CENTER command does adaptive grasping.
The syntax is as follows:
CENTER <arm>\∃
∀\106\GATH\gathers force and torque data\∃
∀\107\\ The GATHER command is used for collecting
force data during the next motion. You should put in as many
components as you are interested in. The syntax is as follows:
GATHER(c1,c2,...,cn)
where c1,c2,..cn are components and may be any of the terms
FX,FY,FZ,MX,MY,MZ,T1,T2,T3,T4,T5,T6,TBL. The first six represent
forces and torques in the principal directions. If TBL is specified,
the quantities are in table coordinates, otherwise in hand coordinates.
T1 thru T6 represent forces measured according to joints.
The gather command sets up the preparatory commands
for the next motion command, and after the next interaction
with the runtime system which involves a motion, the data
will be read back into POINTY and be available to be examined by
the GRAPH command.\∃
∀\108\DECL\declaration statement\∃
∀\109\\ Declarations may be made explicitly as
in the case of AL, or implicitly by means of assignment statements.
Explicit declarations may be made by means of the following
syntactical construct:
<data_type> <variable list>
where <data_type> is one of SCALAR, VECTOR, ROT, TRANS, FRAME or
EVENT. <variable list> consists of a series of identifiers
separated by commas.
Arrays may be declared by including ARRAY after the data type,
e.g.
SCALAR ARRAY S[1:10,3:5]
The indices may be constants or scalar expressions. Scalar
arrays will be initialized to 0, vector arrays to nilvect,
rot arrays to nilrot, trans and frame arrays to niltrans.
Macros are declared by means of the DEFINE statement,
while procedures declarations are described in detail elsewhere.\∃
∀\110\CONT\list of control statements\∃
∀\111\IF\IF statement\∃
∀\112\\ The IF statement has the following syntax:
IF <scalar exp> THEN <statement>
or IF <scalar exp> THEN <statement> ELSE <statement>
The IF statement cannot be used as an expression.\∃
∀\113\FOR\FOR statement\∃
∀\114\\ The FOR statement has the following syntax:
FOR <scalar> ← <scal exp> STEP <scal exp> UNTIL <scal exp>
DO <statement>\∃
∀\115\DO\DO statement\∃
∀\116\\ The DO statement has the following syntax:
DO <statement> UNTIL <condition>
<statement> will be executed until <condition> becomes TRUE\∃
∀\117\WHILE\WHILE statement\∃
∀\118\\ The WHILE statement has the following syntax:
WHILE <cond> DO <statement>
<cond> is a scalar expression, and is checked. If it is TRUE( non zero)
<statement> is executed and the <cond> checked and <statement>
executed and the sequence repeated until <cond> becomes FALSE(0).\∃
∀\119\OTHERS\these are some of the other AL instructions\∃
∀\120\COMM\this describes use of COMMENTS\∃
∀\121\\ There are two forms of comment statements.
The first form is having the reserved word COMMENT followed
by anything and ended by a semicolon. The second
form is enclosing the comment between open and close brace pairs
e.g. {this is a comment} which may appear anywhere. Note that
the delimiters may be nested.\∃
∀\122\NON_AL\these non AL instructions facilitate interaction\∃
∀\123\EDIT\permits the changing of the value of simple variables\∃
∀\124\\ The EDIT command displays the values of
variables to be displayed in the line editor
and permits the user to change their values. The syntax of the
command is as follows:
EDIT <variable name>
where <variable name> is the name of the appropriate variable to be
changed. Currently only scalars, vectors, transes, rots or frames
variables which are not arrays may be edited. Macros may also be
edited by means of this command.
The EDIT command argument is sticky, i.e. if a variable
name is not given, it will assume that it is the last variable that
was edited.\∃
∀\125\EEDIT\writes the macro in a file and swaps to E\∃
∀\126\\ The EEDIT command takes a macro name
as argument and writes it out into a disk file. The core image
is then saved, and the program swaps to E where the user is
permitted to make changes to the macro body. This is particularly
useful when the macro body is a long one and many changes need
to be made to it. Minor changes may be made by means of the
EDIT command.
When you are satisfied with the macro, type <control>X RUN
and you will get back to POINTY. In the meantime please make sure
not to change the state of the program on the PDP-11.\∃
∀\127\DEL\deletes some or all variables\∃
∀\128\\ The DELETE command deletes all the user
defined variables or some of them. The syntax is as follows:
DELETE ALL
DELETE <variable list>
In the first form, all user declared variables are
deleted after asking for confirmation. In the second form
POINTY will complain if some of the variables in the list are
non existent. In the second form, frame arrays may not be
deleted. Also, individual elements of an array may not
be deleted.
A more liberal form of the instruction is executed
if DELETE is replaced by QDELETE. In the first form, confirmation
is not asked for, while in the second form, POINTY does not
complain if the name in the variable list is non existent\∃
∀\129\GRAPH\explains the GRAPH command\∃
∀\130\\ The syntax of the graph command is simply
GRAPH. This command gets you into the module which helps to
plot and save force data on a disk file or display on a data disc.
This command is valid only after a GATHER and move. On exiting
the GRAPH module, the data is destroyed in order to reclaim the
space which the data occupies for some other purpose.\∃
∀\131\SETS\explains the SETSTATUS and RESETSTATUS commands\∃
∀\132\\ The SETSTATUS and RESETSTATUS commands
are used to set compiler variables. The syntax is as follows:
SETSTATUS(<var>,<value>)
RESETSTATUS(<var>,<value>)
If <value> is left out, it defaults to 1 in the case of SETSTATUS
and 0 in the case of RESETSTATUS. <var> currently may be the
following:
NOELF - no output to the ELF
NOFOLD - no constant folding and evaluation of constant
scalars and reals
LINE - prints out the expanded version of the last
statement on the terminal
PPCODE - the pcode of the statement being parsed will
printed out at the terminal
PWCODE - the pcode of the statement being parsed will be
appended to the file PPCODE.FOO
ALPRIN - subsequent printout of variables in AL format
rather than POINTY format
PRTIME - prints the execution time for the current
instruction\∃
∀\133\ERROR\talks about how to handle errors\∃
∀\134\NOARM\what to do if there is no arm action\∃
∀\135\\ When the arm does not do what you expect
it to do, namely move, there will probably be a message printed
out at the VT05 console which may explain the error.
One of the commonest forms of errors is that the power
supply is off or one of the brake switches is off. For the
former, turn on the arm motor power by hitting the big red
button on the underside of one of the short sides of the table.
Sometimes the arm seems to move in weird fashions,
or will claim that it cannot move to the PARK position!
When this happens, it may be that the arm is not properly
initialised. In this case, just reload and start the system
again.
There are two forms of recovery. RETRY<alt>G at the
VT05 will try to repeat the motion, while <alt>P will go on
with the next instruction. DO NOT ever type <alt>G during execution
of POINTY since this will throw the synchronization out, unless
you know what you are doing.\∃
∀\136\PARSE\explanation of error messages\∃
∀\137\\ POINTY is based on the assumption
that it will be used interactively, and any errors encountered
during parsing a statement results in abandoning any further
processing and giving control back to the user.
This may cause grief if move commands
and errors occur in a disk file instead of in the terminal
input mode.
It also means that if you are trying to write
a long program interactively you better not make any typing
mistakes, or you will have to start over.
It is much easier to build up programs as macros
and to edit the macros if they do not behave as you think they
should. When you are happy with the macros, declare a procedure
with the appropriate macro as body.\∃
∀\138\SYNTAX\syntax of statements\∃
∀\139\\ WRITE ALL INTO <filename>
WRITE <variable list> INTO <filename>
WRITE INTO <filename>
READ <filename>
QREAD <filename>
LOAD_VARIABLES <filename>
DUMP_VARIABLES <filename>
SAVECOREIMAGE <filename>\∃
∀\140\\ REDISPLAY
NODISPLAY
DISPLAY <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT>
SHOW <variable list>
VT05_ON
VT05_OFF\∃
∀\141\\ SCALAR s1,s2,s3,.....
VECTOR v1,v2,v3,...
ROT r1,r2,r3,...
TRANS t1,t2,t3,...
FRAME f1,f2,f3,...
EVENT e1,e2,e3,...
<SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT> ARRAY a[l1:u1,l2:u2,...ln:un]\∃
∀\142\DONE\quits help mode\∃
∀\143\DEBUG\details of the high level debugger\∃
∀\144\\
DOCUMENTATION OF THE DEBUGGING FACILITIES IN POINTY
---------------------------------------------------
To set POINTY in debug mode the instruction
SETSTATUS(DEBUG) or
DEBUGON
are required. You can reset POINTY to the normal mode by typing
RESETSTATUS(DEBUG) or
DEBUGOFF
When in debug mode POINTY will stop at the beginning of any compound
statement you type in, while it doesn't stop if you type in a simple
statement.
When in debug mode POINTY reads general POINTY expressions typed by the
user, evaluates them in the context of the place in the program where
execution was suspended. The evaluation is performed just as if the user
had inserted an extra statement into the original program at the point
where execution was suspended. The user may ask to evaluate any POINTY
expression whose evaluation would be legal at the point at which the
execution of the program was suspended.
POINTY prompts the user for input by typing a ⊂:*:⊃. Input can be edited
using the standard line editor. The activation character is the semicolon
or the carriage return, whathever comes first.
The POINTY instructions typed are numbered starting from 1, so that
reference to an instruction can be done through its number, or
referred to as coordinate.
--------------------------------------------------------------------------
Here is the list of instructions available ONLY in debug mode:
--------------------------------------------------------------------------
BREAK(COORD)
BREAK("PROCEDURE_NAME", COORD)
Put a breakpoint at the specified point.
HALT
Send the control to the 10.
TEXT
TEXT(MIN#)
TEXT(MIN#,MAX#)
TEXT("PROCEDURE_NAME",MIN#)
TEXT("PROCEDURE_NAME",MIN#,MAX#)
Show the source text, from MIN# to MAX#. If MAX# < MIN# set MAX# to be
MIN#+MAX#. If MAX# is omitted set it to be MIN#. If both numbers are
omitted show the next instruction to be executed.
RESTART
Restart the program from the beginning. Can be called only when outside
from procedures.
TRAPS
Show the exixting breakpoints.
UNBREAK(COORD)
UNBREAK("PROCEDURE_NAME", COORD)
Remove a breakpoint from the specified point. Complain if no breakpoint
has been set.
!!GO, <CONTROL>G
Continue the execution, from the point where it was suspended.
!!STEP, <CONTROL>S
Execute next statement and stop after that.
!!GSTEP, <CONTROL>X
Execute next statement, considering compound statement or procedure calls
as a single statement, and stops after that.
--------------------------------------------------------------------------
KNOWN BUGS
--------------------------------------------------------------------------
TRAPS shows the breakpoints in the main program and in untyped procedures
(doesn't work yet for typed procedures)
COBEGIN/COEND cause severe problems. Don't try it!
\∃
∀\145\SYSTEM\building up a new POINTY system\∃
∀\146\SYS10\building up system on the PDP-10\∃
∀\147\\ The system on the PDP-10 part can be built up
easily
by means of the instruction "DO PCOMP[PNT,HE]". This DO file does
deletes all the .REL files which are no longer valid, rewrites
INTOPS.SAI, and then proceeds to compile each of the files in the
POINTY system separately. It then loads the files and writes
out the PDP-10 part of the POINTY system as PONTY0.
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.\∃
∀\148\SYS11\building up the POINTY runtime system\∃
∀\149\\ There are four parts to the RUNTIME system and
generally two parts have to be reassembled. Reassamble POINTY.PAL
and PNTARM.PAL on [PNT,HE], and these files will automatically call
in AL.PAL and ARM.PAL respectively. Then to load up the 11 and
get a .SAV file do the following:
.A ARM
.R 11TTY
*Z500000
*LPOINTY[PNT,HE]
*OPNTARM[PNT,HE]
*OK1[11,SYS]
*OPNTY[PNT,HE]
*W160000
*1
*ATERM
*VT05
*SD <now on the VT05 type <alt>G and wait for scanning>
*ATOP
*500000
*DPOINTY
*X
.
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.\∃
∀\150\SYSALL\describes building up the POINTY system\∃
∀\151\\ The part on the 10 and the runtime must first be
built up, as described in SYS10 and SYS11. Then do the following:
.A ARM
.R 11TTY
*GPOINTY[PNT,HE]
*X
.RU PONTY0[PNT,HE]
When everything is working fine, type the instruction
SAVECOREIMAGE P0
The coreimage of both the parser on the 10 and the runtime system
on the the 11 will be saved in a file named P0. To resume the
execution at a later date, type RU P0. If you want to get at this
file by means of R POINTY, then rename this file POINTY.DMP[PNT,HE]
by means of the RENAME command as follows:
RENAME POINTY.DMP[PNT,HE]←P0.DMP
***** CAUTION ****** This is given only as a matter of information.
Don't fool around with all these unless you are one of the people
working with the system.\∃
∀\152\\\∃